home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 090 / pctmay86.arc / DOSFNS.H < prev    next >
C/C++ Source or Header  |  1986-03-11  |  6KB  |  229 lines
  1. /*  ================================================
  2. **  dosfns.h -- Miscellaneous routine to call MS-DOS
  3. **              system functions or perform system
  4. **              specific tasks.
  5. **  ================================================
  6. */
  7.  
  8. /*  getdfs -- Get Disk Free Space.  Returns
  9. **            information on disk capacity
  10. **            and available space.
  11. **    Input:
  12. **        drive = target drive (A=0, B=1, ...)
  13. **
  14. **    Output:
  15. **        avail = number of available clusters
  16. **        total = total clusters on disk
  17. **        sectsize = bytes/sector for disk
  18. **    Returns:
  19. **        Number of sectors per cluster
  20. **        -1 if drive has invalid sectors/cluster
  21. */
  22. getdfs(drive, avail, total, sectsize)
  23. int drive;
  24. unsigned *avail, *total, *sectsize;
  25. {
  26.   union REGS regs;
  27.  
  28.   regs.x.dx = drive+1;
  29.   regs.x.ax = 0x3600;
  30.   intdos(®s, ®s);
  31.   *avail = regs.x.bx;
  32.   *total = regs.x.dx;
  33.   *sectsize = regs.x.cx;
  34.   return(regs.x.ax);
  35. }
  36. /*  parse -- Parse filename into FCB.  This
  37. **           function takes a command line and
  38. **           parses it for a file name of the form
  39. **           d:filename.ext.
  40. **
  41. **           Bits in mode control parsing:
  42. **
  43. **           bit 0=1 : ignore leading separators
  44. **           bit 1=1 : change drive id only if one given
  45. **           bit 2=1 : change filename only if one given
  46. **           bit 3=1 : change extension only if one given
  47. **
  48. **           returns -1 if drive invalid.
  49. */
  50. parse(filename, fcb, mode)
  51. char filename[];
  52. struct ext_fcb *fcb;
  53. int mode;
  54. {
  55.   union REGS regs;
  56.   union SREGS segregs;
  57.  
  58.   regs.x.si = (unsigned) filename;
  59.   segread(&segregs);
  60.   segregs.es = segregs.ds;
  61.   regs.x.di = (unsigned) fcb;
  62.   regs.h.al = (unsigned char) mode;
  63.   regs.h.ah = 0x29;
  64.   intdosx(®s, ®s, &segregs);
  65.   return((int) regs.h.al);
  66. }
  67. /*  setdta -- Set Disk Transfer Address.
  68. **            Sets the DOS disk transfer address
  69. **            to be the address of buffer.
  70. */
  71. setdta(buffer)
  72. char buffer[];
  73. {
  74.   union REGS regs;
  75.  
  76.   regs.x.ax = 0x1A00;
  77.   regs.x.dx = (unsigned) buffer;
  78.   intdos(®s, ®s);
  79. }
  80. /*  search_first -- Search for First Directory Entry.
  81. **                  On entry fcb contains an extended
  82. **                  File Control Block with file name
  83. **                  and attribute bits set.  On exit
  84. **                  fcb contains matched entry unless
  85. **                  return code is 255, in which case
  86. **                  no match was found.
  87. */
  88. search_first(fcb)
  89. struct ext_fcb *fcb;
  90. {
  91.   union REGS regs;
  92.  
  93.   regs.x.ax = 0x1100;
  94.   regs.x.dx = (unsigned) fcb;
  95.   intdos(®s, ®s);
  96.   return((int) regs.h.al);
  97. }
  98. /*  search_next -- Search for Next Directory Entry.
  99. **                 Same as search_first except for
  100. **                 use on subsequent calls.
  101. */
  102. search_next(fcb)
  103. struct ext_fcb *fcb;
  104. {
  105.   union REGS regs;
  106.  
  107.   regs.x.ax = 0x1200;
  108.   regs.x.dx = (unsigned) fcb;
  109.   intdos(®s, ®s);
  110.   return((int) regs.h.al);
  111. }
  112. /*  current_drv -- This function returns the drive number
  113. **                 of the current default drive (A=0,
  114. **                 B=1, C=2, etc.).
  115. */
  116. current_drv()
  117. {
  118.   union REGS regs;
  119.  
  120.   regs.x.ax = 0x1900;
  121.   intdos(®s, ®s);
  122.   return((int) regs.h.al);
  123. }
  124. /*  select_drv -- This function changes the current default
  125. **                drive to the specified drive (A=0,
  126. **                B=1, C=2, etc.).  Returns total number of
  127. **                drives.
  128. */
  129. select_drv(drv)
  130. int drv;
  131. {
  132.   union REGS regs;
  133.  
  134.   regs.x.ax = 0x0E00;
  135.   regs.x.dx = (unsigned) drv;
  136.   intdos(®s, ®s);
  137.   return((int) regs.h.al);
  138. }
  139. /*  get_table -- This function returns a "far" pointer to
  140. **               the parameters table for the specified
  141. **               disk drive (A=0, B=1, etc.).
  142. */
  143. struct disk_table far *get_table(drv)
  144. int drv;
  145. {
  146.   struct disk_table far *t;
  147.  
  148.   union REGS regs;
  149.   union SREGS segregs;
  150.  
  151.   regs.x.ax = 0x3200;
  152.   regs.x.dx = drv+1;
  153.   segread(&segregs);
  154.   intdosx(®s, ®s, &segregs);
  155.   FP_SEG(t) = segregs.ds;
  156.   FP_OFF(t) = regs.x.bx;
  157.   return(t);
  158. }
  159. /*  dtoa -- Takes date in Microsoft packed
  160. **          format and converts it to an ASCII
  161. **          string as : "Mmm, dd, yr"
  162. */
  163. dtoa(date, s)
  164. struct ms_date date;
  165. char s[];
  166. {
  167.   static char *mo_str[] = {
  168.     "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  169.     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
  170.   };
  171.  
  172.   strcpy(s, "            ");
  173.   if (date.m != 0)
  174.     sprintf(s, "%s %2d, %4d",
  175.         mo_str[date.m-1], date.d, date.y+1980);
  176. }
  177. /*  ttoa -- Takes time in Microsoft packed
  178. **          format and converts it to an ASCII
  179. **          string as : "HH:MMx", where x is
  180. **          'a' for A.M. and 'p' for P.M.
  181. */
  182. ttoa(time, s)
  183. struct ms_time time;
  184. char s[];
  185. {
  186.   int hr;
  187.   char am_pm;
  188.  
  189.   hr = time.hh;
  190.   strcpy(s, "       ");
  191.   if ((hr != 0) || (time.mm != 0) || (time.xx != 0)) {
  192.     am_pm = (hr >= 12) ? 'p' : 'a';
  193.     hr %= 12;
  194.     if (hr == 0)
  195.       hr += 12;
  196.     sprintf(s, " %2d:%02d%c", hr, time.mm, am_pm);
  197.   }
  198. }
  199. /*  fatval -- This function calculates the logical
  200. **            "chaining" of cluster numbers in a File
  201. **            Allocation Table.  Given an entry
  202. **            cluster number it calculates the next
  203. **            cluster using the array fat[].
  204. **
  205. **            If is12 is TRUE then fat[] is assumed to
  206. **            contain 12 bit entries, otherwise fat[]
  207. **            is assumed to contain 16 bit entries.
  208. */
  209. fatval(is12, cluster, fat)
  210. int is12;
  211. unsigned cluster;
  212. unsigned char fat[];
  213. {
  214.   unsigned clword, cloffset;
  215.  
  216.   if (is12) {
  217.     /* 12 bit FAT lookup */
  218.     cloffset = 3*cluster/2;
  219.     clword = fat[cloffset] + (fat[cloffset + 1] << 8);
  220.     if (cluster & 1)
  221.       return (clword >> 4);     /* odd cluster  */
  222.     else
  223.       return (clword & 0x0FFF); /* even cluster */
  224.   }
  225.   else
  226.     /* 16 bit FAT lookup */
  227.     return (((unsigned int *) fat)[cluster]);
  228. }
  229.